home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / misc / volume5 / tracer < prev    next >
Encoding:
Text File  |  1989-02-03  |  26.5 KB  |  1,012 lines
  1. Path: xanth!nic.MR.NET!hal!ncoast!allbery
  2. From: sid@chinet.UUCP (Sid Grange)
  3. Newsgroups: comp.sources.misc
  4. Subject: v05i046: ray tracing program for 3b1
  5. Message-ID: <12883@ncoast.UUCP>
  6. Date: 9 Nov 88 03:39:27 GMT
  7. Sender: allbery@ncoast.UUCP
  8. Reply-To: sid@chinet.UUCP (Sid Grange)
  9. Lines: 1000
  10. Approved: allbery@ncoast.UUCP
  11.  
  12. Posting-number: Volume 5, Issue 46
  13. Submitted-by: "Sid Grange" <sid@chinet.UUCP>
  14. Archive-name: tracer
  15.  
  16. [The author claims that it should be portable to other graphical Un*x systems.
  17. Since I don't have one handy, I've no way to test that.  ++bsa]
  18.  
  19. #! /bin/sh
  20. # This is a shell archive.  Remove anything before this line, then unpack
  21. # it by saving it into a file and typing "sh file".  To overwrite existing
  22. # files, type "sh file -c".  You can also feed this as standard input via
  23. # unshar, or by typing "sh <file", e.g..  If this archive is complete, you
  24. # will see the following message at the end:
  25. #        "End of shell archive."
  26. # Contents:  Makefile README.DOC README.HAK bdata.i conv.c extern.h
  27. #   find.c g_bal.c g_bod.c macros.h refract.c rtd.h shade.c support.c
  28. #   tracer.c
  29. # Wrapped by sid@chinet on Mon Feb  8 20:03:07 1988
  30. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  31. if test -f Makefile -a "${1}" != "-c" ; then 
  32.   echo shar: Will not over-write existing file \"Makefile\"
  33. else
  34. echo shar: Extracting \"Makefile\" \(536 characters\)
  35. sed "s/^X//" >Makefile <<'END_OF_Makefile'
  36. Xtracer: tracer.o shade.o find.o support.o refract.o g_bod.o g_bal.o
  37. X    cc tracer.o shade.o find.o support.o refract.o g_bod.o g_bal.o -lm -o tracer
  38. Xfind.o: find.c rtd.h extern.h macros.h
  39. X    cc -c find.c 
  40. Xshade.o: shade.c rtd.h extern.h macros.h
  41. X    cc -c shade.c 
  42. Xsupport.o: support.c rtd.h extern.h
  43. X    cc -c support.c 
  44. Xtracer.o: tracer.c rtd.h bdata.i macros.h
  45. X    cc -c tracer.c  
  46. Xrefract.o: refract.c rtd.h extern.h macros.h
  47. X    cc -c refract.c  
  48. Xg_bod.o: g_bod.c extern.h macros.h
  49. X    cc -c g_bod.c  
  50. Xg_bal.o: g_bal.c extern.h rtd.h
  51. X    cc -c g_bal.c  
  52. END_OF_Makefile
  53. if test 536 -ne `wc -c <Makefile`; then
  54.     echo shar: \"Makefile\" unpacked with wrong size!
  55. fi
  56. # end of overwriting check
  57. fi
  58. if test -f README.DOC -a "${1}" != "-c" ; then 
  59.   echo shar: Will not over-write existing file \"README.DOC\"
  60. else
  61. echo shar: Extracting \"README.DOC\" \(2252 characters\)
  62. sed "s/^X//" >README.DOC <<'END_OF_README.DOC'
  63. X
  64. X
  65. X
  66. XTRACER(99)                  FRITZZ GRAPHICS            TRACER(99)
  67. X
  68. X
  69. X
  70. XNAME
  71. X     tracer- run a simple ray tracing procedure
  72. X
  73. XSYNOPSIS
  74. X     tracer -o [filename] -i [filename] -s <filename> -S<number>
  75. X
  76. XDESCRIPTION
  77. X     Tracer is a program developed originally to study how
  78. X     ray tracing works, and was later modified to the present state
  79. X     to make it more compatible for animated film production.
  80. X
  81. X     It is capable of depicting a number of balls (up to 150)
  82. X     and a plane that is covered with a tiling of any bitmapped picture.
  83. X
  84. X
  85. XOPTIONS
  86. X     -o Chooses the output data file. If no argument is givin, stdout
  87. X        is used. If the option is not used the default is data.dis.
  88. X
  89. X     -i Chooses the input (ball) data file. If no argument is given, stdin
  90. X        is used. If the option is not used the default is bdata.i.
  91. X 
  92. X     -s Chooses the file containing the tiling bitmap. It requires an
  93. X        an argument. If the option is not used the default is pat.def.
  94. X
  95. X     -S Chooses contrast of the pattern. 0.0 is no contrast, 1.0 is maximum
  96. X        contrast. 1.0 is the default. (useful for fading during animation)
  97. X
  98. XPROGRAM NOTES
  99. X     This program generates a file containing a header with x and y sizes,
  100. X     followed by the data in 8-bit greyscale, one pixel to a character, in 
  101. X     scanlines.
  102. X     There are two neccessary input files: ball data, and a pattern bitmap.
  103. X     The tiling bitmap can be digitized data, it must be in the form of 
  104. X     scan lines no longer than 512 bytes followed by newlines.
  105. X     the ball data is of the following form:
  106. X
  107. X     x y z rad ior refract reflect diffuse ambient
  108. X
  109. X     on each line where x y & z are the coordinates of the center of 
  110. X     the ball, rad is the radius of the ball, ior is the index of refraction
  111. X     for translucent materials (index of refraction for glass is about 1.5)
  112. X     the last four numbers determine how much of each atrribute is used.
  113. X     Thus a pure silver ball would have 0.0 1.0 0.0 0.0 as the last numbers,
  114. X     and a pure glass ball would have 1.0 0.0 0.0 0.0 .
  115. X
  116. X
  117. XFILES
  118. X     ./bdata.i    default ball data
  119. X     ./pat.def  default floor pattern
  120. X     ./data.dis default output file
  121. X
  122. XBUGS
  123. X     As with any good software, the complexity of this program hides 
  124. X     all bugs.
  125. X
  126. END_OF_README.DOC
  127. if test 2252 -ne `wc -c <README.DOC`; then
  128.     echo shar: \"README.DOC\" unpacked with wrong size!
  129. fi
  130. # end of overwriting check
  131. fi
  132. if test -f README.HAK -a "${1}" != "-c" ; then 
  133.   echo shar: Will not over-write existing file \"README.HAK\"
  134. else
  135. echo shar: Extracting \"README.HAK\" \(1259 characters\)
  136. sed "s/^X//" >README.HAK <<'END_OF_README.HAK'
  137. X***** A Hackers Guide to Tracer *****
  138. Xtracer consists of a bunch of files containing a program that does 
  139. Xray tracing (No shit sherlock).
  140. XThes files are as follows:
  141. Xtracer.c:    main() sets up the initial rays and stores values
  142. X        in a file. booboo prints an error message and quits.
  143. Xshade.c:    shade() calculates the intensity returned by a ray. It is
  144. X         recursive, and also makes a call to refract().
  145. Xrefract.c:    The most difficult part of the program. This file contains
  146. X        refract(), inside(), refk() and getcapt().
  147. X        and these do all the refraction calculations.
  148. Xfind.c:        contains find(),findo() (for when a ray is inside a ball)
  149. X        and shadow() and finds() for shadows.
  150. Xsupport.c:    supportive subroutines. right now only contains mt_vec
  151. X        as all the others were either discarded or converted to 
  152. X        macros.
  153. Xg_bal.c        g_bal() gets the ball data and points bl[] at them.
  154. Xg_bod.c        g_bod() loads the floor pattern into suzie.
  155. X
  156. Xmacros.h    contains all the macro definitions. Definitely to be looked at.
  157. Xrtd.h        header file containing all the structure definitions.
  158. Xextern.h    keeps track of all global variables used through the program.
  159. X
  160. Xbdata.i        sample ball data file.
  161. X
  162. Xpat.def \
  163. Xcheck.pat\
  164. Xsusie.pat >-    sample pattern files. (susie is not for the purient).
  165. Xship.pat /
  166. X
  167. END_OF_README.HAK
  168. if test 1259 -ne `wc -c <README.HAK`; then
  169.     echo shar: \"README.HAK\" unpacked with wrong size!
  170. fi
  171. # end of overwriting check
  172. fi
  173. if test -f bdata.i -a "${1}" != "-c" ; then 
  174.   echo shar: Will not over-write existing file \"bdata.i\"
  175. else
  176. echo shar: Extracting \"bdata.i\" \(213 characters\)
  177. sed "s/^X//" >bdata.i <<'END_OF_bdata.i'
  178. X
  179. X-30.0 10.0 400.0 50.0 0.0 0.0 0.0 0.9 0.1
  180. X210.0 175.0 400.0 50.0 0.0 0.0 0.3 0.6 0.1
  181. X40.0 110.0 450.0 50.0 0.0 0.0 0.6 0.3 0.1
  182. X140.0 65.0 450.0 50.0 0.0 0.0 0.9 0.0 0.1
  183. X
  184. X220.0 70.0 100.0 60.0 1.4 0.9 0.0 0.0 0.1
  185. END_OF_bdata.i
  186. if test 213 -ne `wc -c <bdata.i`; then
  187.     echo shar: \"bdata.i\" unpacked with wrong size!
  188. fi
  189. # end of overwriting check
  190. fi
  191. if test -f conv.c -a "${1}" != "-c" ; then 
  192.   echo shar: Will not over-write existing file \"conv.c\"
  193. else
  194. echo shar: Extracting \"conv.c\" \(824 characters\)
  195. sed "s/^X//" >conv.c <<'END_OF_conv.c'
  196. X#include <stdio.h>
  197. X#include <tam.h>
  198. X#include <fcntl.h>
  199. X  
  200. Xextern errno;
  201. X
  202. Xmain(argc, argv)
  203. Xint argc;
  204. Xchar *argv[];
  205. X
  206. X{
  207. X  char *malloc();
  208. X  char *cd,*d;
  209. X  short *bm,*c;
  210. X  int fd, cont;
  211. X register int a,b;
  212. X
  213. X    cont = 60; 
  214. X/*    if((argc == 2) && (atoi(argv[1]) >1) && (atoi(argv[1]) <100))
  215. X        cont = atoi(argv[1]);*/
  216. X 
  217. X    if ((fd=open(argv[1],O_RDONLY|O_NDELAY))==0) {
  218. X      fprintf("couldn't open %s for read\n", argv[1]);
  219. X      exit(-1);
  220. X    }
  221. X    if(lseek(fd,8,0)<0)
  222. X      exit(-1);
  223. X    cd=malloc(134400);
  224. X    if(read(fd,cd,134400)!=134400)
  225. X      exit(-1);
  226. X    bm=malloc(14974);
  227. X    c=bm+7487;
  228. X    for(a=287;a>=0;a--) {
  229. X      d=a*420+cd;
  230. X      for(b=415;b>=0;b--) {
  231. X        if(!(b&15))
  232. X          c-=1;
  233. X        *c=(*c<<1)|(*(d+b)>60);
  234. X      }
  235. X    }
  236. X    cd=bm;
  237. X    a = 0;
  238. X    while(a++ != 14974)
  239. X        fprintf(stdout, "%c", *cd++);
  240. X}
  241. END_OF_conv.c
  242. if test 824 -ne `wc -c <conv.c`; then
  243.     echo shar: \"conv.c\" unpacked with wrong size!
  244. fi
  245. # end of overwriting check
  246. fi
  247. if test -f extern.h -a "${1}" != "-c" ; then 
  248.   echo shar: Will not over-write existing file \"extern.h\"
  249. else
  250. echo shar: Extracting \"extern.h\" \(130 characters\)
  251. sed "s/^X//" >extern.h <<'END_OF_extern.h'
  252. Xextern double suzie[300][300],sam;
  253. Xextern struct ball *bl[];
  254. Xextern struct sphere ls;
  255. Xextern int level,nob;
  256. Xextern int xsue,ysue;
  257. END_OF_extern.h
  258. if test 130 -ne `wc -c <extern.h`; then
  259.     echo shar: \"extern.h\" unpacked with wrong size!
  260. fi
  261. # end of overwriting check
  262. fi
  263. if test -f find.c -a "${1}" != "-c" ; then 
  264.   echo shar: Will not over-write existing file \"find.c\"
  265. else
  266. echo shar: Extracting \"find.c\" \(1942 characters\)
  267. sed "s/^X//" >find.c <<'END_OF_find.c'
  268. X#include <math.h>
  269. X#include "rtd.h"
  270. X#include "extern.h"
  271. X#include "macros.h"
  272. X
  273. X
  274. Xdouble  findo (m, s) /* finds where a ray inside the ball exits. */
  275. Xstruct mat *m;
  276. Xstruct sphere  *s;
  277. X{
  278. X/* foops id the rotated position vector. */
  279. X    struct vector   foops;
  280. X    double  t;
  281. X    MTV (foops, (*m), s -> cent);
  282. X/* see if it hits the ball (it better)*/
  283. X    t = s -> rad * s -> rad - foops.y * foops.y - foops.z * foops.z;
  284. X    if (t > 0)
  285. X    t = foops.x + sqrt (t);
  286. X    else
  287. X    t = 0;
  288. X/* return how far along the ray you were when you hit */
  289. X    return (t);
  290. X}
  291. X
  292. Xdouble  find (m, s)/* finds whether a ray hits a ball*/
  293. Xstruct mat *m;
  294. Xstruct sphere  *s;
  295. X{
  296. X    struct vector   foops;
  297. X    double  t;
  298. X    MTV (foops, (*m), s -> cent);
  299. X    t = s -> rad * s -> rad - foops.y * foops.y - foops.z * foops.z;
  300. X    if (t > 0)
  301. X    t = foops.x - sqrt (t);
  302. X    else
  303. X    t = 0;
  304. X    return (t);
  305. X}
  306. X
  307. Xdouble  finds (m, s)/* finds if a ball is between a point and a 
  308. X            lightsource. Returns how obscuring the ball is */
  309. Xstruct mat *m;
  310. Xstruct sphere  *s;
  311. X{
  312. X    struct vector   foops;
  313. X    double  t;
  314. X    MTV (foops, (*m), s -> cent);
  315. X    t = s -> rad - sqrt (foops.y * foops.y + foops.z * foops.z);
  316. X    if (t > 0)
  317. X    t = t / foops.x;
  318. X    else
  319. X    t = 0;
  320. X    return (t);
  321. X}
  322. X
  323. X
  324. X
  325. X
  326. Xdouble  shadow (p)/* finds if a point is in a shadow, or if it is on edge */
  327. Xstruct vector  *p;
  328. X{
  329. X    struct mat  trans;
  330. X    struct sphere   ss;
  331. X    struct vector   d;
  332. X    int     c,
  333. X            i;
  334. X    double  l,
  335. X            k,
  336. X            x,
  337. X            y,
  338. X            z,
  339. X            finds ();
  340. X    l = 0.0;
  341. X    c = -1;
  342. X    SV (d, ls.cent, (*p));
  343. X    d.l = LEN (d);
  344. X    d.xzl = XZL (d);
  345. X    mt (&(d), &trans);
  346. X
  347. X    for (i = 0; i < nob; i++) {
  348. X    ss.rad = bl[i] -> s.rad;
  349. X    SV (ss.cent, bl[i] -> s.cent, (*p));
  350. X    if ((k = finds (&trans, &ss)) > l) {
  351. X        c = i;
  352. X        l = k;
  353. X    }
  354. X    }
  355. X    if (c == -1)
  356. X    k = 200.0;
  357. X    else {
  358. X    k = 1.0 - l / ((ls.rad) / (d.l));
  359. X    if (k < 0.0)
  360. X        k = 0.0;
  361. X    k *= 200.0;
  362. X    }
  363. X    return (k);
  364. X}
  365. END_OF_find.c
  366. if test 1942 -ne `wc -c <find.c`; then
  367.     echo shar: \"find.c\" unpacked with wrong size!
  368. fi
  369. # end of overwriting check
  370. fi
  371. if test -f g_bal.c -a "${1}" != "-c" ; then 
  372.   echo shar: Will not over-write existing file \"g_bal.c\"
  373. else
  374. echo shar: Extracting \"g_bal.c\" \(652 characters\)
  375. sed "s/^X//" >g_bal.c <<'END_OF_g_bal.c'
  376. X#include <stdio.h>
  377. X#include "rtd.h"
  378. X#include "extern.h"
  379. Xg_bal (df)
  380. XFILE * df;
  381. X{
  382. X    int     i;
  383. X    double  x,
  384. X            y,
  385. X            z,
  386. X            r,
  387. X            ior,
  388. X            rfr,
  389. X            rfl,
  390. X            dif,
  391. X            amb;
  392. X    for (i = 0;
  393. X        fscanf (df, "%F %F %F %F %F %F %F %F %F",
  394. X        &x, &y, &z, &r, &ior, &rfr, &rfl, &dif, &amb) != EOF;
  395. X        i++) {
  396. X    bl[i] = (struct ball   *) malloc (sizeof (struct ball));
  397. X    bl[i] -> s.cent.x = x;
  398. X    bl[i] -> s.cent.y = y;
  399. X    bl[i] -> s.cent.z = z;
  400. X    bl[i] -> s.rad = r;
  401. X    bl[i] -> ior = ior;
  402. X    bl[i] -> rfr = rfr;
  403. X    bl[i] -> rfl = rfl;
  404. X    bl[i] -> dif = dif;
  405. X    bl[i] -> amb = amb;
  406. X    }
  407. X    return (i);
  408. X}
  409. X
  410. END_OF_g_bal.c
  411. if test 652 -ne `wc -c <g_bal.c`; then
  412.     echo shar: \"g_bal.c\" unpacked with wrong size!
  413. fi
  414. # end of overwriting check
  415. fi
  416. if test -f g_bod.c -a "${1}" != "-c" ; then 
  417.   echo shar: Will not over-write existing file \"g_bod.c\"
  418. else
  419. echo shar: Extracting \"g_bod.c\" \(595 characters\)
  420. sed "s/^X//" >g_bod.c <<'END_OF_g_bod.c'
  421. X#include <stdio.h>
  422. X#include <math.h>
  423. X#include "extern.h"
  424. X#include "macros.h"
  425. X
  426. X
  427. Xg_bod (f)
  428. XFILE * f;
  429. X{
  430. X    int     k,
  431. X            x;
  432. X    double  big = 0.0,
  433. X            little = HUGE;
  434. X    char    buf[512];
  435. X
  436. X
  437. X    for (ysue = 0;; ysue++) {
  438. X    if (fgets (buf, 512, f) == NULL)
  439. X        break;
  440. X    xsue = strlen (buf) - 1;
  441. X    for (x = 0; x < xsue; x++) {
  442. X        k = buf[x];
  443. X        suzie[x][ysue] = (double) k;
  444. X        if (big < k)
  445. X        big = k;
  446. X        if (little > k)
  447. X        little = k;
  448. X    }
  449. X    }
  450. X    big = big - little;
  451. X    for (k = 0; k < ysue; k++)
  452. X    for (x = 0; x < xsue; x++)
  453. X        suzie[x][k] = (suzie[x][k] - little) / big;
  454. X}
  455. END_OF_g_bod.c
  456. if test 595 -ne `wc -c <g_bod.c`; then
  457.     echo shar: \"g_bod.c\" unpacked with wrong size!
  458. fi
  459. # end of overwriting check
  460. fi
  461. if test -f macros.h -a "${1}" != "-c" ; then 
  462.   echo shar: Will not over-write existing file \"macros.h\"
  463. else
  464. echo shar: Extracting \"macros.h\" \(1116 characters\)
  465. sed "s/^X//" >macros.h <<'END_OF_macros.h'
  466. X/* some of the most important stuff in the program */
  467. X#define DOT(v1,v2) (v1.x*v2.x+v1.y*v2.y+v1.z*v2.z)
  468. X/* returns dot product of two vectors */
  469. X#define LN2(v)       (DOT(v,v))
  470. X/* returns the square of the length of a vector */
  471. X#define LEN(v)       sqrt(LN2(v))
  472. X/* guess */
  473. X#define XZL(v)       sqrt(v.x*v.x+v.z*v.z)
  474. X/* returns the component in the xz plane of a vector */
  475. X#define SCMLT(sc,vct) vct.x*= sc;vct.y*= sc;vct.z*= sc;vct.l*= sc;
  476. X/* multiplies a vetor by a scalar */
  477. X#define MV(a,b,c,v)   v.x= a;v.y= b;v.z= c;
  478. X/* makes a vector. wouldn't need this with c++ */
  479. X#define SV(t,u,v)  t.x=u.x-v.x;t.y=u.y-v.y;t.z=u.z-v.z;
  480. X/*subtract vector t=u-v */
  481. X#define AV(t,u,v)  t.x=u.x+v.x;t.y=u.y+v.y;t.z=u.z+v.z;
  482. X/* add vector t=u+v */
  483. X#define MTV(v1,m,v2) MV(DOT(m.x,v2),DOT(m.y,v2),DOT(m.z,v2),v1)
  484. X/* multiply transpose matrix by vector. v1=m*v2 */
  485. X
  486. X#define LEVEL 5/* levels of recursion */
  487. X#define RLEV  3/*don't want as many inside the ball, takes forever as it is*/
  488. X
  489. X#define XMIN 10.0
  490. X#define XMAX 220.0
  491. X#define YMIN 10.0
  492. X#define YMAX 170.0
  493. X/* window size,  virtual units */
  494. X#define SCALE  2.0
  495. X/* maginification factor */
  496. END_OF_macros.h
  497. if test 1116 -ne `wc -c <macros.h`; then
  498.     echo shar: \"macros.h\" unpacked with wrong size!
  499. fi
  500. # end of overwriting check
  501. fi
  502. if test -f refract.c -a "${1}" != "-c" ; then 
  503.   echo shar: Will not over-write existing file \"refract.c\"
  504. else
  505. echo shar: Extracting \"refract.c\" \(2965 characters\)
  506. sed "s/^X//" >refract.c <<'END_OF_refract.c'
  507. X#include <math.h>
  508. X#include "rtd.h"
  509. X#include "macros.h"
  510. X#include "extern.h"
  511. X
  512. Xint    rlev;
  513. Xint     refract (r, bll)
  514. Xstruct ray *r;
  515. Xstruct ball *bll;
  516. X{
  517. X    struct vector   new,
  518. X                    norm;
  519. X    struct mat  trans;
  520. X    struct ray  ir;
  521. X    double  l,
  522. X            refk (), getcapt (), capt, inside ();
  523. X    double  stupid;
  524. X    struct sphere   ss;
  525. X
  526. X    SV (norm, r -> org, bll -> s.cent);
  527. X    norm.l = bll-> s.rad;
  528. X
  529. X    capt = getcapt (&norm, &(r -> dir), bll -> ior);
  530. X
  531. X
  532. X/* get the addition factor for the normal for refraction*/
  533. X    stupid = refk (&(norm), &(r -> dir), bll -> ior);
  534. X    SCMLT (stupid, norm);
  535. X
  536. X    AV (ir.dir, r -> dir, norm);
  537. X    MV (r -> org.x, r -> org.y, r -> org.z, ir.org);
  538. X
  539. X/* now get it for reflection */
  540. X    SV (norm, r -> org, bll -> s.cent);
  541. X    norm.l = bll -> s.rad;
  542. X    SCMLT (1.0 / norm.l, norm);
  543. X    stupid = 2.0 * DOT (norm, r -> dir);
  544. X    SCMLT (stupid, norm);
  545. X    SV (r -> dir, r -> dir, norm);
  546. X
  547. X    return ((int) ((1.0 - capt) * (double) shade (r) + ((capt) * inside (&ir, bll))));
  548. X}
  549. X
  550. Xdouble  inside (r, bll)
  551. Xstruct ray *r;
  552. Xstruct ball *bll;
  553. X{
  554. X    struct vector   new,
  555. X                    norm;
  556. X    struct mat  trans;
  557. X    struct ray  er;
  558. X    double  findo (), lght, l, refk (), getcapt (), capt;
  559. X    double  stupid;
  560. X    struct sphere   ss;
  561. X
  562. X
  563. X    if (++rlev < RLEV) {
  564. X    r -> dir.l = LEN (r -> dir);
  565. X    r -> dir.xzl = XZL (r -> dir);
  566. X    mt (&(r -> dir), &trans);
  567. X    ss.rad = bll -> s.rad;
  568. X    SV (ss.cent, bll -> s.cent, r -> org);
  569. X
  570. X    l = findo (&trans, &ss);
  571. X    MV (l * trans.x.x, l * trans.x.y, l * trans.x.z, new);
  572. X    AV (er.org, r -> org, new);
  573. X    AV (r -> org, r -> org, new);
  574. X    SV (norm, er.org, bll -> s.cent);
  575. X
  576. X    norm.l = bll -> s.rad;
  577. X    capt = getcapt (&norm, &(r -> dir), 1.0 / bll -> ior);
  578. X
  579. X    stupid = refk (&norm, &(r -> dir), 1.0 / bll -> ior);
  580. X    SCMLT (stupid, norm);
  581. X    AV (er.dir, norm, r -> dir);
  582. X
  583. X    SCMLT (1.0 / norm.l, norm);
  584. X    stupid = 2.0 * DOT (norm, r -> dir);
  585. X    SCMLT (stupid, norm);
  586. X    SV (r -> dir, r -> dir, norm);
  587. X    lght = (1.0 - capt) * inside (r, bll) + (capt * (double) shade (&er));
  588. X    }
  589. X    else
  590. X    lght = 0.0;
  591. X    rlev--;
  592. X     if (lght<0.0) lght=0.0;
  593. X     if (lght>255.0) lght=255.0;
  594. X    return (lght);
  595. X}
  596. X
  597. X
  598. X
  599. Xdouble  refk (nrm, in, ior)
  600. Xstruct vector  *nrm,
  601. X               *in;
  602. Xdouble  ior;
  603. X{
  604. X    double  dt,
  605. X            ln,
  606. X            li,
  607. X            ret;
  608. X
  609. X    ior = ior * ior;
  610. X    dt = DOT ((*nrm), (*in));
  611. X    ln = LN2 ((*nrm));
  612. X    li = LN2 ((*in));
  613. X    if (dt < 0)
  614. X    ret = (-dt - sqrt (dt * dt - ln * li * (1 - ior))) / ln;
  615. X    else
  616. X    ret = (-dt + sqrt (dt * dt - ln * li * (1 - ior))) / ln;
  617. X    return (ret);
  618. X}
  619. X
  620. Xdouble  getcapt (nrm, dr, ior)
  621. Xstruct vector  *nrm,
  622. X               *dr;
  623. Xdouble  ior;
  624. X{
  625. X    double  dt,
  626. X            cs1,
  627. X            cs2,
  628. X            p,
  629. X            s;
  630. X    dt = DOT ((*nrm), (*dr));
  631. X    dt = dt * dt / LN2 ((*nrm)) / LN2 ((*dr));
  632. X    cs1 = sqrt (dt);
  633. X    cs2 = sqrt (1.0 - (1.0 - dt) / ior);
  634. X    p = cs1 / (cs1 + ior * cs2);
  635. X    s = cs1 / (ior * cs1 + cs2);
  636. X    return (2.0 * (p * p + s * s));
  637. X}
  638. END_OF_refract.c
  639. if test 2965 -ne `wc -c <refract.c`; then
  640.     echo shar: \"refract.c\" unpacked with wrong size!
  641. fi
  642. # end of overwriting check
  643. fi
  644. if test -f rtd.h -a "${1}" != "-c" ; then 
  645.   echo shar: Will not over-write existing file \"rtd.h\"
  646. else
  647. echo shar: Extracting \"rtd.h\" \(434 characters\)
  648. sed "s/^X//" >rtd.h <<'END_OF_rtd.h'
  649. Xstruct color {
  650. Xint r;int g;int b;};
  651. X
  652. Xstruct vector {
  653. Xdouble x;
  654. Xdouble y;
  655. Xdouble z;
  656. Xdouble l;
  657. Xdouble xzl;} ;
  658. X
  659. Xstruct ray {
  660. Xstruct vector org;
  661. Xstruct vector dir;} ;
  662. X
  663. Xstruct sphere {
  664. Xstruct vector cent;
  665. Xdouble rad;} ;
  666. X
  667. Xstruct ball {
  668. Xstruct sphere s;
  669. Xdouble ior;
  670. Xdouble rfr;
  671. Xdouble rfl;
  672. Xdouble dif;
  673. Xdouble amb;
  674. X};
  675. X
  676. Xstruct mat {
  677. Xstruct vector x;  /* first !row! */
  678. Xstruct vector y;  /*second !row! */
  679. Xstruct vector z;}; /* third !row! */
  680. X
  681. END_OF_rtd.h
  682. if test 434 -ne `wc -c <rtd.h`; then
  683.     echo shar: \"rtd.h\" unpacked with wrong size!
  684. fi
  685. # end of overwriting check
  686. fi
  687. if test -f shade.c -a "${1}" != "-c" ; then 
  688.   echo shar: Will not over-write existing file \"shade.c\"
  689. else
  690. echo shar: Extracting \"shade.c\" \(3454 characters\)
  691. sed "s/^X//" >shade.c <<'END_OF_shade.c'
  692. X/*
  693. X * this subroutine does all the gritty work- it calculates 
  694. X * what shade each pixel should be. I like recursion.
  695. X */
  696. X#include <math.h>
  697. X#include "rtd.h"
  698. X#include "macros.h"
  699. X#include "extern.h"
  700. X
  701. Xint     shade (r)
  702. Xstruct ray *r;
  703. X{
  704. X    int     i,
  705. X            c,
  706. X            refract ();
  707. X    struct ray  refr;
  708. X    double  lght,
  709. X            x,
  710. X            y,
  711. X            z,
  712. X            l,
  713. X            k,
  714. X            dot (), find (), shadow ();
  715. X    int     sx,
  716. X            sy;
  717. X    double  stupid;
  718. X    struct vector   new,
  719. X                    norm;
  720. X    struct mat  trans;
  721. X    struct sphere   ss;
  722. X    if (++level <= LEVEL) {
  723. X    c = -1;
  724. X    l = HUGE;
  725. X/* get vector length and xz component for mt() */
  726. X    r -> dir.l = LEN (r -> dir);
  727. X    r -> dir.xzl = XZL (r -> dir);
  728. X/* make a transform matrix that rotates something in space so
  729. X   that the ray will be aligned with the x axis */
  730. X    mt (&(r -> dir), &trans);
  731. X
  732. X/* for starters we find out whether we hit anything. */
  733. X    for (i = 0; i < nob; i++) {
  734. X        ss.rad = bl[i] -> s.rad;
  735. X        SV (ss.cent, bl[i] -> s.cent, r -> org);
  736. X        if ((k = find (&trans, &ss)) > 0.0 && k < l) {
  737. X        c = i;
  738. X        l = k;
  739. X        }
  740. X    }
  741. X    if (c >= 0 && (l * trans.x.y + r -> org.y) > 0.0) {
  742. X                /* WE HIT SOMETHING */
  743. X        MV (l * trans.x.x, l * trans.x.y, l * trans.x.z, new);
  744. X        new.l=l;
  745. X/* move the new orgin of the ray to the intersection */
  746. X        AV (refr.org, new, r -> org);
  747. X        AV (r -> org, new, r -> org);
  748. X        MV (r -> dir.x, r -> dir.y, r -> dir.z, refr.dir);
  749. X/* get a normal vector for the intersection point */
  750. X        SV (norm, r -> org, bl[c] -> s.cent);
  751. X        norm.l=bl[c] ->s.rad;
  752. X
  753. X/* ambient lighting */
  754. X        lght = 200.0 * bl[c] -> amb;
  755. X
  756. X/* shaded lighting (diffuse). subroutine shadow is in find.c */
  757. X        if (bl[c] -> dif != 0.0) {
  758. X        SV (new, ls.cent, r -> org);
  759. X        new.l = LEN(new);
  760. X        if ((k = DOT (new, norm)) > 0.0)
  761. X            lght += bl[c] -> dif * shadow (&(r -> org)) * k / (new.l) / (norm.l);
  762. X        }
  763. X
  764. X/*reflection... easy */
  765. X        if (bl[c] -> rfl != 0.0) {
  766. X/* make the normal unit length */
  767. X        SCMLT ((1.0 / norm.l), norm);
  768. X/* get the length of the ray's component in the normal direction */
  769. X        stupid = 2.0 * DOT (norm, r -> dir);
  770. X        SCMLT (stupid, norm);
  771. X/* subtract double the normal component- !reflection! */
  772. X        SV (r -> dir, r -> dir, norm);
  773. X        lght += bl[c] -> rfl * (double) shade (r);
  774. X        }
  775. X
  776. X/* refraction. this is ugly, which is why I choose to deal with
  777. X   it in it's own subroutine which comes after this one */
  778. X        if (bl[c] -> rfr != 0.0) {
  779. X        lght += bl[c] -> rfr * (double) refract (&refr, bl[c]);
  780. X        }
  781. X
  782. X
  783. X
  784. X    }
  785. X    else {            /* hit no objects... */
  786. X        if ((r -> dir.y) < 0.0) {/* crosses floor */
  787. X        z = -(r -> org.y) / (r -> dir.y);
  788. X        (r -> org.x) += z * (r -> dir.x);
  789. X        (r -> org.z) += z * (r -> dir.z);
  790. X        (r -> org.y) = 0.0;
  791. X
  792. X        SV (new, ls.cent, r -> org);
  793. X        new.l = LEN(new);
  794. X        sx = (int) (r -> org.x / 1.5) % xsue;
  795. X        if (sx < 0)
  796. X            sx += xsue;
  797. X        sy = -(int) (r -> org.z / 1.5) % ysue;
  798. X        if (sy < 0)
  799. X            sy += ysue;
  800. X        lght = (sam * suzie[sx][sy] + 1.0 - sam) * (0.8 *
  801. X            shadow (&(r -> org)) * (new.y) / (new.l) + 40.0);
  802. X
  803. X
  804. X        }
  805. X        else {        /* check to see if it hit lightsource */
  806. X        SV (ss.cent, ls.cent, r -> org);
  807. X        ss.rad = ls.rad;
  808. X        if (find (&trans, &(ss.cent)) > 0.0)
  809. X            lght = 255;
  810. X        else
  811. X            lght = 0;
  812. X        }
  813. X    }
  814. X    }
  815. X/* to many levels return 0 cause it shouldn't matter */
  816. X    else
  817. X    lght = 0;
  818. X    level--;
  819. X    if (lght < 0.0)
  820. X    lght = 0.0;
  821. X    if (lght > 255.0)
  822. X    lght = 255.0;
  823. X    return ((int) lght);
  824. X}
  825. END_OF_shade.c
  826. if test 3454 -ne `wc -c <shade.c`; then
  827.     echo shar: \"shade.c\" unpacked with wrong size!
  828. fi
  829. # end of overwriting check
  830. fi
  831. if test -f support.c -a "${1}" != "-c" ; then 
  832.   echo shar: Will not over-write existing file \"support.c\"
  833. else
  834. echo shar: Extracting \"support.c\" \(834 characters\)
  835. sed "s/^X//" >support.c <<'END_OF_support.c'
  836. X/*
  837. X *    supportive subroutines...
  838. X */
  839. X
  840. X#include <math.h>
  841. X#include <stdio.h>
  842. X#include "rtd.h"
  843. X#include "extern.h"
  844. X
  845. X
  846. Xmt (vec, trans)
  847. Xstruct vector  *vec;
  848. Xstruct mat *trans;
  849. X{
  850. X    if (vec -> xzl == 0.0) {
  851. X    trans -> x.x = 0.0;
  852. X    trans -> x.y = 1.0;
  853. X    trans -> x.z = 0.0;
  854. X    trans -> y.x = -1.0;
  855. X    trans -> y.y = 0.0;
  856. X    trans -> y.z = 0.0;
  857. X    trans -> z.x = 0.0;
  858. X    trans -> z.y = 0.0;
  859. X    trans -> z.z = 1.0;
  860. X    }
  861. X    else {
  862. X    trans -> x.x = (vec -> x) / (vec -> l);
  863. X    trans -> x.y = (vec -> y) / (vec -> l);
  864. X    trans -> x.z = (vec -> z) / (vec -> l);
  865. X    trans -> y.x = -(vec -> x) * (vec -> y) / ((vec -> l) * (vec -> xzl));
  866. X    trans -> y.y = (vec -> xzl) / (vec -> l);
  867. X    trans -> y.z = -(vec -> z) * (vec -> y) / ((vec -> l) * (vec -> xzl));
  868. X    trans -> z.x = -(vec -> z) / (vec -> xzl);
  869. X    trans -> z.y = 0;
  870. X    trans -> z.z = (vec -> x) / (vec -> xzl);
  871. X    }
  872. X}
  873. END_OF_support.c
  874. if test 834 -ne `wc -c <support.c`; then
  875.     echo shar: \"support.c\" unpacked with wrong size!
  876. fi
  877. # end of overwriting check
  878. fi
  879. if test -f tracer.c -a "${1}" != "-c" ; then 
  880.   echo shar: Will not over-write existing file \"tracer.c\"
  881. else
  882. echo shar: Extracting \"tracer.c\" \(2624 characters\)
  883. sed "s/^X//" >tracer.c <<'END_OF_tracer.c'
  884. X
  885. X
  886. X/* tracer version 2.1 */
  887. X#include <stdio.h>
  888. X#include <math.h>
  889. X#include "rtd.h"
  890. X#include "macros.h"
  891. X
  892. X
  893. XFILE * fp;
  894. Xdouble  suzie[300][300],
  895. X        sam = 1.0;
  896. Xint     xsue,
  897. X        ysue;
  898. Xstruct ball *bl[150];
  899. Xint     level,
  900. X        nob;
  901. Xstruct sphere   ls;
  902. X
  903. Xmain (argc, argv)
  904. Xint     argc;
  905. Xchar  **argv;
  906. X{
  907. X    FILE * df, *texfile;
  908. X    static double   xco,
  909. X                    yco;
  910. X    struct ray  rr;
  911. X    struct vector   vp;
  912. X    double  x,
  913. X            y,
  914. X            z;
  915. X    int     i,
  916. X            in = 0,
  917. X            out = 0,
  918. X            tex = 0;
  919. X    int     c;
  920. X
  921. X/* command interp */
  922. X
  923. X    for (i = 1; i < argc; i++) {
  924. X    if (argv[i][0] != '-')
  925. X        booboo ("Options strt with a '-' bozo");
  926. X    c = argv[i][1];
  927. X
  928. X    switch (c) {
  929. X        case ('i'): 
  930. X        if (in)
  931. X            booboo ("Sorry, but you may only have one input file");
  932. X        in = 1;
  933. X        if ((i + 1) >= argc || argv[i + 1][0] == '-')/* no arg */
  934. X            df = stdin;
  935. X        else
  936. X            if ((df = fopen (argv[++i], "r")) == NULL)
  937. X            booboo ("input file not found");
  938. X        break;
  939. X        case ('o'): 
  940. X        if (out)
  941. X            booboo ("Sorry, but you may have only one output file");
  942. X        out = 1;
  943. X        if ((i + 1) >= argc || argv[i + 1][0] == '-')/* no arg */
  944. X            fp = stdout;
  945. X        else
  946. X            fp = fopen (argv[++i], "w");
  947. X        break;
  948. X        case ('s'): 
  949. X        if (tex)
  950. X            booboo ("Sorry, but you may have only one image file");
  951. X        if ((i + 1) >= argc || argv[i + 1][0] == '-')/* no arg */
  952. X            booboo ("-s requires an argument");
  953. X        tex = 1;
  954. X        if ((texfile = fopen (argv[++i], "r")) == NULL)
  955. X            booboo ("image file not found");
  956. X        break;
  957. X        booboo ("this line shouldn't do anything");
  958. X        case ('S'): 
  959. X        if (argv[i][2] < '0' || argv[i][2] > '9'){
  960. Xprintf("%c\n",argv[i][2]);
  961. X            booboo ("-S needs a numerical argument");}
  962. X        sam = atof (&(argv[i][2]));
  963. X        break;
  964. X        default: 
  965. X        booboo ("Unrecognized option. Better try again");
  966. X    }
  967. X    }
  968. X
  969. X
  970. X    if (!in)
  971. X    if ((df = fopen ("bdata.i", "r")) == NULL)
  972. X        booboo ("bdata.i not found");
  973. X    if (!out)
  974. X    fp = fopen ("data.dis", "w");
  975. X    if (!tex)
  976. X    if ((texfile = fopen ("pat.def", "r")) == NULL)
  977. X        booboo ("pat.def not found");
  978. X
  979. X
  980. X
  981. X    nob = g_bal (df);
  982. X    g_bod (texfile);
  983. X
  984. X
  985. X
  986. X    MV (95.0, 140.0, -200.0, vp);
  987. X    MV (0.0, 900.0, 0.0, ls.cent);
  988. X    ls.rad = 40;
  989. X    fprintf (fp, "%d %d\n", (int) ((XMAX - XMIN) * SCALE +0.9999999), (int) ((YMAX - YMIN) * SCALE +0.9999999));
  990. X
  991. X    for (yco = YMAX * SCALE; yco > YMIN * SCALE; yco--)
  992. X    for (xco = XMIN * SCALE; xco < XMAX * SCALE; xco++) {
  993. X        MV (xco / SCALE, yco / SCALE, 0.0, rr.org);
  994. X        SV (rr.dir, rr.org, vp);
  995. X        fprintf (fp, "%c", shade (&rr));
  996. X    }
  997. X}
  998. X
  999. Xbooboo (str)
  1000. Xchar   *str; {
  1001. X    printf ("%s\n", str);
  1002. X    exit (-1);
  1003. X}
  1004. END_OF_tracer.c
  1005. if test 2624 -ne `wc -c <tracer.c`; then
  1006.     echo shar: \"tracer.c\" unpacked with wrong size!
  1007. fi
  1008. # end of overwriting check
  1009. fi
  1010. echo shar: End of shell archive.
  1011. exit 0
  1012.